Internet Surfer 2.0/Internet Surfer 2.0 (Wayzata Technology) (1996).iso/pc/text/mac/faqs.357

Text File | 1996-02-12 | 28.6 KB | 597 lines

Frequently Asked Questions (FAQS);faqs.357



The mailing list [e-mail] is for any and all
discussions of Dylan, including language design issues, implementation
issues, marketing issues, syntax issues, etc. The mailing list
[e-mail] is for major announcements about
Dylan, such as the availability of new implementations, new versions
of the manual, etc.  This mailing list should be *much* lower volume
than info-dylan.  Everything sent to this list is also sent to
info-dylan.  The mailing list [e-mail] is
for people who are working on Dylan implementations. (To be added to
dylan-builders, send a note describing your implementation plans to
dylan-builders-request.) Apple hopes to set up a comp.lang.dylan
newsgroup to be gatewayed to the info-dylan mailing list.

Send mail to the -request version of the list to be added to it.

Apple hasn't announced plans to release Dylan as a product.

The directory cambridge.apple.com:pub/dylan contains some documents
pertaining to Dylan, including a FAQ list.

========

Thomas is a compiler for a language that is compatible with the
language described in the book "Dylan(TM) an object-oriented dynamic
language" by Apple Computer Eastern Research and Technology, April
1992. Thomas was written at Digital Equipment Corporation's Cambridge
Research Laboratory. Thomas is NOT Dylan(TM) and was built with no
direct input, aid, assistance or discussion with Apple.

Thomas is available to the public by anonymous ftp at
       crl.dec.com:pub/DEC/Thomas
       gatekeeper.pa.dec.com:pub/DEC/Thomas
       altdorf.ai.mit.edu:archive/Thomas

The Thomas system is written in Scheme and runs under MIT's CScheme,
DEC's Scheme->C, and Marc Feeley's Gambit.  It can run on a wide range
of machines including the Macintosh, PC compatibles, Vax, MIPS, Alpha,
and 680x0.  Thomas generates IEEE compatible Scheme code.

DEC CRL's goals in building Thomas were to learn about Dylan by
building an implementation, and to build a system they could use to
write small Dylan programs. As such, Thomas has no optimizations of
any kind and does not perform well.

The original development team consisted of:
          Matt Birkholz ([e-mail])
          Jim Miller ([e-mail])
          Ron Weiss ([e-mail])
In addition, Joel Bartlett ([e-mail]), Marc Feeley
([e-mail]), Guillermo Rozas ([e-mail])
and Ralph Swick ([e-mail]) contributed time and energy to the
initial release.

----------------------------------------------------------------
[4-7] What Lisp-related discussion groups and mailing lists exist?

Before posting to any discussion group, please read the rest
of this FAQ, to make sure your question isn't already answered.

First of all, there are several lisp-related newsgroups:
   comp.lang.lisp          General Lisp-related discussions.
                           See below for archive information.
   comp.lang.clos          Discussion related to CLOS, PCL, and
                           object-oriented programming in Lisp.
                           Gatewayed to [e-mail].
                           (or equivalently, [e-mail])
                           See below for info on the newsgroup's archives.
   comp.lang.lisp.mcl      Discussions related to Macintosh
                           Common Lisp. This newsgroup is gatewayed
                           to the [e-mail]
                           mailing list and archived on cambridge.apple.com.
   comp.lang.lisp.franz    Discussion of Franz Lisp, a dialect of Lisp.
                           (Note: *not* Franz Inc's Allegro.)
   comp.lang.lisp.x        Discussion of XLISP, a dialect of Lisp.
   comp.sys.xerox          Discussions related to using Medley (name exists
                           for historical reasons, and is likely to change
                           soon). Gatewayed to the info-1100 mailing list.
   comp.windows.garnet     Garnet, a Lisp-based GUI.
   comp.lang.scheme        General Scheme-related discussion.
                           This newsgroup is gatewayed to the
                           [e-mail] mailing list.
   comp.lang.scheme.c      Discussion of C-Scheme, a scheme dialect.
                           This newsgroup is gatewayed to the
                           [e-mail] mailing list.
   comp.ai and subgroups   General AI-related dicusssion.


The newsgroup comp.lang.lisp is archived on ftp.gmd.de by month, from
1989 onward. Individual files are in rnews format. (They contain
articles prefixed by a header line "#! rnews <nchars> archive" where
<nchars> is the number of characters in the article following the
header. That format is convenient for various news processing programs
(e.g.  relaynews) and is rather easy to process from a lisp program too.)
A copy of the GMD archives for comp.lang.lisp is available on
cambridge.apple.com:pub/comp.lang.lisp.


We list several mailing lists below. In general, to be added to
a mailing list, send mail to the "-request" version of the address.
This avoids flooding the mailing list with annoying and trivial
administrative requests.

General Lisp Mailing Lists:

   [e-mail]          Technical discussion of Common Lisp.
   [e-mail]         Low volume mailing list associated with
                                   the Lisp Utilities repository at CMU.
                                   Do *NOT* post directly to this list.
                                   Send mail to
                                      [e-mail]
                                   instead and the moderator will either
                                   answer your question or post
                                   the message for you.
   [e-mail]              A mailing list concerning the contents
                                   of this FAQ posting.
   [e-mail]           Discussion of Scheme. Gatewayed to
                                   the comp.lang.scheme newsgroup.
   [e-mail]               General discussion about Scheme.

Particular Flavors of Lisp:

   [e-mail]    Macintosh Common Lisp. Gatewayed
                                   to the comp.lang.lisp.mcl newsgroup.

   [e-mail]           CMU Common Lisp bug reports

   [e-mail]                 Symbolics Lisp Users Group

   [e-mail]  Franz Allegro Common Lisp

   [e-mail]                     Kyoto Common Lisp
                                   Archived in cli.com:pub/kcl/kcl-mail-archive
   [e-mail]       Forwards to [e-mail].

   [e-mail]          LispWorks

   [e-mail]  TI Explorer Lisp Machine
   [e-mail]  TI Explorer Lisp Machine

   [e-mail]  Xerox/Envos Lisp machine environment,
                                   InterLisp-D, and Medley. Gatewayed to
                                   the newsgroup comp.sys.xerox.

   [e-mail],
   [e-mail]  C-Scheme. Gatewayed to the
                                   comp.lang.scheme.c newsgroup.

   [e-mail]           T, a dialect of Scheme.

   [e-mail]    PseudoScheme

   [e-mail]      The Franz Lisp Language.

Lisp Windowing Systems:

   [e-mail]           Common Lisp Window System Discussions.
   [e-mail]        CLX (Common Lisp X Windows)
   [e-mail]                    Common Lisp Interface Manager
   [e-mail]      Common Lisp User-Interface Environment
   [e-mail]      Express Windows
   [e-mail]         Garnet (send mail to [e-mail]
                                   or [e-mail] to be added)
   [e-mail]         GINA and CLM
   [e-mail]       LispWorks
   [e-mail]       WINTERP (OSF/Motif Widget INTERPreter)
   [e-mail]         YYonX

Lisp Object-Oriented Programming:

   [e-mail]  (same as [e-mail])
        PCL (Xerox PARC's portable implementation of CLOS).
        Gatewayed to the comp.lang.clos newsgroup.
        The mailing list is archived on nervous.cis.ohio-state.edu in
        the directory pub/lispusers/commonloops.
        The CLOS code repository is in pub/lispusers/clos.

Miscellaneous:

   [e-mail]
           Use of Lisp and Lisp-based systems in statistics.
   [e-mail]
           Franz Inc's GNU-Emacs/Lisp interface.

----------------------------------------------------------------
[4-8]   What are R4RS and IEEE P1178?

R4RS is the Revised^4 Report on the Algorithmic Language Scheme,
edited by W. Clinger and J. Rees. It appeared in ACM Lisp Pointers IV,
July-September 1991, and also as MIT AI Memo 848b. It serves as a kind
of standard for the language. It can be obtained by anonymous ftp at
the two Scheme Repositories, altdorf.ai.mit.edu and nexus.yorku.ca.

IEEE P1178 is IEEE Standard 1178-1990, "IEEE Standard for the Scheme
Programming Language", published by IEEE in 1991. ISBN 1-55937-125-0.
It is now also an ANSI standard. It may be ordered from IEEE by
calling 1-800-678-IEEE and using order number SH14209.
----------------------------------------------------------------
[4-9]   How do I do object-oriented programming in Scheme?

Some Scheme implementations (for example, MacScheme, Feel, Oaklisp,
and PC-Scheme) include built-in object-oriented extensions.

MEROON is a package written in Scheme to provide the basic facilities
of an object-oriented programming style through three macros:
define-class, define-generic, and define-method. MEROON offers simple
inheritance, reflective metaclasses and simple dispatching generic
functions. MEROON also offers indexed fields subsuming Scheme vectors
without inheritance restrictions. Meroon runs in Scheme->C, PC-Scheme,
Chez Scheme, Elk, Gambit. MEROON sources and documentation may be
found in the Scheme Repository as
   nexus.yorku.ca:pub/scheme/new/meroon.*.tar.Z
and also from
   nuri.inria.fr:INRIA/icsla/meroon*.tar.Z.

For information on YASOS (Yet Another Scheme Object System), see
"Scheming with Objects" in the October 1992 issue of AI Expert magazine.

----------------------------------------------------------------

;;; *EOF*
Xref: bloom-picayune.mit.edu comp.lang.lisp:8753 comp.lang.clos:1593 news.answers:4563
Path: bloom-picayune.mit.edu!enterpoop.mit.edu!spool.mu.edu!uunet!ogicse!das-news.harvard.edu!cantaloupe.srv.cs.cmu.edu!crabapple.srv.cs.cmu.edu!mkant
From: [e-mail] (Mark Kantrowitz)
Newsgroups: comp.lang.lisp,comp.lang.clos,news.answers
Subject: FAQ: CLOS and PCL Questions 5/6 [Monthly posting]
Summary: Questions about CLOS, PCL and object-oriented programming in Lisp
Message-ID: <[e-mail]>
Date: 13 Dec 92 09:03:06 GMT
Article-I.D.: cs.lisp-faq-5.text_724237355
Expires: Tue, 26 Jan 1993 09:02:35 GMT
Sender: [e-mail] (Usenet News System)
Reply-To: [e-mail]
Followup-To: poster
Organization: School of Computer Science, Carnegie Mellon
Lines: 237
Approved: [e-mail]
Supersedes: <[e-mail]>
Nntp-Posting-Host: a.gp.cs.cmu.edu

Archive-name: lisp-faq/part5
Last-Modified: Thu Nov  5 19:30:40 1992 by Mark Kantrowitz
Version: 1.27

;;; ****************************************************************
;;; Answers to Frequently Asked Questions about Lisp ***************
;;; ****************************************************************
;;; Written by Mark Kantrowitz and Barry Margolin
;;; lisp-faq-5.text -- 11959 bytes

This post contains Part 5 of the Lisp FAQ. It is cross-posted to the
newsgroup comp.lang.clos because it contains material of interest to
people concerned with CLOS, PCL and object-oriented programming in
Lisp. The other parts of the Lisp FAQ are posted only to the
newsgroups comp.lang.lisp and news.answers.

If you think of questions that are appropriate for this FAQ, or would
like to improve an answer, please send email to us at [e-mail].

CLOS/PCL Questions (Part 5):

  [5-0]   What is CLOS (PCL) and where can I get it?
          How do you pronounce CLOS?
  [5-1]   What documentation is available about object-oriented
          programming in Lisp?
  [5-2]   How I write a function that can access defstruct slots by
          name?  I would like to write something like
          (STRUCTURE-SLOT <object> '<slot-name>).
  [5-3]   How can I list all the CLOS instances in a class?
  [5-4]   How can I store data and CLOS instances (with possibly circular
          references) on disk so that they may be retrieved at some later
          time?
  [5-5]   Given the name of a class, how can I get the names of its slots?

Search for [#] to get to question number # quickly.

In general, questions about object oriented programming in Lisp,
especially questions about using CLOS or compiling PCL, should be
directed to the newsgroup comp.lang.clos.

----------------------------------------------------------------
[5-0]  What is CLOS (PCL) and where can I get it?
       How do you pronounce CLOS?

CLOS (Common Lisp Object System) is the object-oriented programming
standard for Common Lisp. It is the successor to Symbolics FLAVORS and
Xerox LOOPS (Lisp Object Oriented Programming System). The acronym
CLOS is pronouned either as "See-Loss" or "Closs", depending on taste.
PCL (Portable Common Loops) is a portable CLOS implementation, and is
available by anonymous ftp from parcftp.xerox.com (13.1.64.94) in the
/pub/pcl/ directory. Also in the same directory are sources for CLX R5
and an inspecter.

The sources for the CLOS Metaobject Protocol specification are
also available from parcftp as /pub/pcl/mop/spec.tar.Z. See also the book
``The Art of the Metaobject Protocol'' below. The Closette files
related to this book are available from parcftp as /pub/pcl/mop/closette.lisp.

----------------------------------------------------------------
[5-1] What documentation is available about object-oriented
      programming in Lisp?

Books about object-oriented programming in Lisp include:

   1. dpANS CL describes the entire Common Lisp language, which includes the
      CLOS standard.  Informally, CLtL2 can also be used to learn about CLOS,
      but please remember that CLtL2 is not an official X3J13 committee
      document. (The presentation of CLtL2 differs from that of the draft
      proposed standard, and some matters of fact have changed in the proposed
      standard since the publication of CLtL2.)

   2. Sonya E. Keene
      "Object-Oriented Programming in Common Lisp:
       A Programmer's Guide to CLOS"
      Addison-Wesley (Reading, MA), 1989. 266 pages. ISBN 0-201-17589-4.
           Tutorial introduction to CLOS with many examples and
           a lot of good advice for designing large programs using CLOS.

   3. Jo A. Lawless and Molly M. Miller.
      "Understanding CLOS: the Common Lisp Object System"
      Digital Press, 1991. 192 pages.

   4. Gregor Kiczales, Jim des Rivieres, and Daniel G. Bobrow.
      "The Art of the Metaobject Protocol"
      MIT Press, 1991. 335 pages. ISBN 0-262-61074-4
           The first part of the book presents a model CLOS implementation,
           introduces the basic principles of metaobject protocols, and
           works through the key elements of the CLOS Metaobject Protocol.
           The second half is the detailed specification of the CLOS
           Metaobject Protocol. A simple working interpreter suitable
           for experimentation is contained in an appendix.

   5. Robert R. Kessler and Amy R. Petajan.
      "LISP, Objects, and Symbolic Programming"
      Scott, Foresman and Company (Glenview, IL), 1988. 644 pages.
           Includes a small Lisp compiler.
----------------------------------------------------------------
[5-2] How can I write a function that can access defstruct slots by name?  I
      would like to write something like
        (STRUCTURE-SLOT <object> '<slot-name>).

There is currently no portable, built-in way to access structure slots
given only the name.  If your Common Lisp includes an implementation
of CLOS that supports the meta-object protocol specified in the
original X3J13 draft spec (document X3J13/88-003), then it probably will
allow (SLOT-VALUE <object> '<slot-name>); however, not all
implementations of CLOS currently provide this.  Lacking this, some
implementations may provide implementation-dependent functions that
allow access to structure slots by name; note that this may cause
saved images to be larger, as some implementations normally open-code
structure accessors and discard slot name information.

While it is not possible to write a fully general STRUCTURE-SLOT function,
it is not very difficult to write version that handles specific structure
types.  For instance, after defining:

   (defstruct spaceship name captain position velocity)

one may then define:

   (defun spaceship-slot (spaceship slot-name)
     (ecase slot-name
       (name (spaceship-name spaceship))
       (captain (spaceship-captain spaceship))
       (position (spaceship-position spaceship))
       (velocity (spaceship-velocity spaceship))))

or using CLOS (generic functions):

(defgeneric spaceship-slot (spaceship slot-name)
  (:method ((x spaceship) (slot (eql :name)))
    (spaceship-name x))
  (:method ((x spaceship) (slot (eql :captain)))
    (spaceship-captain x))
  (:method ((x spaceship) (slot (eql :position)))
    (spaceship-position x))
  (:method ((x spaceship) (slot (eql :velocity)))
    (spaceship-velocity x)))

Another popular way to define this is:

   (defun spaceship-slot (spaceship slot-name)
     (funcall (symbol-function
                (find-symbol (format nil "SPACESHIP-~A" slot-name)
                             #.(package-name *package*)))
              spaceship))

I personally recommend the first version.  It is likely to be much faster
and more memory efficient than the second version.  It's also easy to get
the second one wrong; many people forget to specify the package argument to
FIND-SYMBOL, which can cause incorrect results when the package at run time
is different from the one at compile time.  Even my version assumes that
SPACESHIP-SLOT is being defined in a file that is in the same package as
the one containing the structure definition; if this isn't the case,
#.(PACKAGE-NAME *PACKAGE*) should be replaced by a string naming the
correct package.

Another workaround is to define a MY-DEFSTRUCT macro that parses the
defstruct arguments and expands into a call to DEFSTRUCT along with a
definition of the runtime slot-accessor function.

Some non-portable techniques include the use of LCL:STRUCTURE-REF
in Lucid and EXCL:STRUCTURE-REF in Allegro.
----------------------------------------------------------------
[5-3] How can I list all the CLOS instances in a class?

There is no built-in way to enumerate the instances of a class.  If you are
only interested in listing the instances of classes that you have defined,
it is not very difficult to implement it as part of your class definition.
Add a shared slot, e.g. ALL-INSTANCES, with an initial value of NIL, to the
class definition.  Then write an after-method on INITIALIZE-INSTANCE for
this class, which pushes the instance being initialized onto ALL-INSTANCES.
Note that this must be done separately for each class that wants to maintain
such a list; it can't be encapsulated in a mixin class, because all its
dependent classes would share the same ALL-INSTANCES slot.  A compromise
would be to use a mixin to define the INITIALIZE-INSTANCE after-method (and
any other general-purpose methods that use the slot), but not the shared
slot; it would be up to the descendant classes to define the slot at the
level of the class hierarchy that is appropriate. You could also try
defining the classes that need instance-recording as instances of a
metaclass that holds the instance registry on the class object. The
recording behavior could then be built-in to an after method on
initialize-instance for the root class of the metaclass, or even
allocate-instance. To allow for garbage collection of old instances,
you will also need to define a generic function to remove the recorded
instances from the list of instances.
----------------------------------------------------------------
[5-4]  How can I store data and CLOS instances (with possibly circular
       references) on disk so that they may be retrieved at some later
       time?

There are two main techniques of doing this kind of persistent object
storage. The first involves using #. to compile the data into a file.
The second produces an ASCII representation which, when evaluated,
will reproduce an equivalent set of data.

If the data you wish to save is stored in the variable *hash-table*,
create a file containing just the lines
        (in-package "YOUR-PACKAGE")
        (setq *hash-table* '#.*hash-table*)
and compile it. The #. macro performs read-time evaluation of the
expression following the dot, and so this compiles the data into the
file. You may then load the file to restore the data. However, the
resulting binary file is not portable between Lisp implementations,
and sometimes not even for the same Lisp on different platforms. Also,
some Lisps will treat the data as constant, and place it on pages in
memory that are marked read-only (after it is loaded). If one tries to
later modify the data, these Lisps will signal an error. Lucid CL only
puts such constants in a read-only area when they appear inside
functions, so this should be safe. Allegro CL doesn't seem to complain
about modification if the data is a cons. DEC's VAXLisp, however, has
problems with #. circular structures in .fas files.

The other technique is to produce an ASCII representation of the Lisp
objects which may then be saved to a file. To reproduce the data, one
can load (or compile and load) the file. This technique is portable
between different Lisps and platforms. Unfortunately, the resulting
data is not necessarily EQ to the original. Kerry Koitzsch's
save-object.lisp package is included in the Lisp Utilities Repository,
ftp.cs.cmu.edu:/afs/cs.cmu.edu/user/mkant/Public/Lisp-Utilities/.
(Note: You must cd to this directory in one atomic operation, as some
of the superior directories on the path are protected from access by
an anonymous ftp.) The Lisp Utilities Repository is described in
detail in the answer to question [6-1].

See also the discussion of MAKE-LOAD-FORM and MAKE-LOAD-FORM-SAVING-SLOTS
in CLtL2.

----------------------------------------------------------------
[5-5]   Given the name of a class, how can I get the names of its slots?

(defun class-slot-names (class-name)
  (mapcar #'clos:slot-definition-name
          (clos:class-slots (find-class class-name))))

----------------------------------------------------------------
;;; *EOF*
Xref: bloom-picayune.mit.edu comp.lang.lisp:8754 comp.lang.scheme:5784 news.answers:4564
Path: bloom-picayune.mit.edu!enterpoop.mit.edu!spool.mu.edu!uunet!ogicse!das-news.harvard.edu!cantaloupe.srv.cs.cmu.edu!crabapple.srv.cs.cmu.edu!mkant
From: [e-mail] (Mark Kantrowitz)
Newsgroups: comp.lang.lisp,comp.lang.scheme,news.answers
Subject: FAQ: Lisp FTP Resources 6/6 [Monthly posting]
Summary: FTP Resources and Free Lisp/Scheme Software
Message-ID: <[e-mail]>
Date: 13 Dec 92 09:03:54 GMT
Article-I.D.: cs.lisp-faq-6.text_724237414
Expires: Tue, 26 Jan 1993 09:03:34 GMT
Sender: [e-mail] (Usenet News System)
Reply-To: [e-mail]
Followup-To: poster
Organization: School of Computer Science, Carnegie Mellon
Lines: 907
Approved: [e-mail]
Supersedes: <[e-mail]>
Nntp-Posting-Host: a.gp.cs.cmu.edu

Archive-name: lisp-faq/part6
Last-Modified: Thu Nov  5 19:30:40 1992 by Mark Kantrowitz
Version: 1.27

;;; ****************************************************************
;;; FTP Archives and Other Resources *******************************
;;; ****************************************************************
;;; Written by Mark Kantrowitz and Barry Margolin
;;; lisp-faq-6.text -- 47389 bytes

This post contains Part 6 of the Lisp FAQ.

If you think of questions that are appropriate for this FAQ, or would
like to improve an answer, please send email to us at [e-mail].

Topics Covered (Part 6):
  [6-0] General information about FTP Resources for Lisp and Scheme
  [6-1] Repositories of Lisp Software
  [6-2] Repositories of Scheme Software
  [6-3] Publicly Redistributable Lisp Software
  [6-4] Publicly Redistributable Scheme Software
  [6-5] How can I use the X Window System or other GUIs from Lisp?
  [6-6] Formatting code in LaTeX

Search for [#] to get to question number # quickly.

----------------------------------------------------------------
[6-0] General information about FTP Resources for Lisp and Scheme

Remember, when ftping compressed or compacted files (.Z, .arc, .fit,
etc.) to use binary mode for retrieving the files.

FTP sites for Lisp/Scheme interpreters and compilers are discussed in
the answer to questions [4-0] and [4-2]. See the entry on Macintosh
Common Lisp in question [4-1] for information on the CD-ROM of Lisp code that
Apple distributes with MCL 2.0.

----------------------------------------------------------------
[6-1] Repositories of Lisp Software

There are several repositories of publicly redistributable and
public domain Lisp code.

   The Lisp Utilities collection is accessible by anonymous ftp
   to any CMU CS machine (e.g., ftp.cs.cmu.edu [128.2.206.173])
   or through AFS in the directory
           /afs/cs.cmu.edu/user/mkant/Public/Lisp-Utilities/
   If accessing this directory through anonymous ftp, it is
   important to "cd" to the directory using one atomic operation, as
   some of the superior directories on the path are protected from
   access by an anonymous ftp.
   Files included in the repository include:
      extensions.lisp         A collection of extensions to Common Lisp.
      initializations.lisp    Brad Miller's initializations packaged
                              for Allegro CL 4.0.
      xref.lisp               Portable cross referencing tool for Lisp.
                              Similar to the Symbolics Who-Calls and
                              the Xerox MasterScope programs.
      defsystem.lisp          Portable system definition facility (a
                              "Make" for lisp). More featureful than
                              other defsystem implementations.
      logical-pathnames.lisp  Portable implementation of the X3J13
                              June 1989 specification for logical pathnames.
      metering.lisp           Portable code time/space profiling tool.
      source-compare.lisp     A portable "diff" utility for Lisp.
      user-manual.lisp        Program which helps with documenting Lisp code.
      psgraph.lisp            Joe Bates' PostScript DAG grapher.
      matcher.lisp            A regexp-like matcher for Lisp.
      framework.lisp          A portable generic frame system.
      date-formatter.lisp     Simple code for formatting a date.
      save-object.lisp        Kerry Koitzsch's package to save ASCII
                              representations of Lisp objects to a file.
      defpackage.lisp         Stephen Nicoud's semi-portable
                              CLtL2 version of defpackage.
      johnson-yacc.lisp       Mark Johnson's lisp YACC.
      ops5.tar.Z              Public domain Common Lisp implementation
                              of the OPS5 production system interpreter.
                              "Expert System Shell".
                              Written by Charles Forgy and ported by
                              George Wood and Jim Kowalski.
      cmu-loop.lisp           Implements the CLtL2 Loop Macro.
      mit-loop.lisp           Implements the CLtL1 Loop Macro.
      sloop.lisp              William Schelter's loop macro, not CLtL1/2.
      yloop.lisp              Frank Ritter and Jim Panagos' implementation
                              of the Yale loop macro described in
                              McDermont, Charniak and Riesbeck's
                              AI programming book. Not CLtL1/2.
      ew/                     Express Windows distribution.
      iterate/                The Iterate Macro.
      series/                 Waters' Series Macro package.
      simplex.lisp            Bruno Haible's implementation of the Simplex
                              algorithm.
      mapforms.tar.Z          Moon's code walker.
      resources.lisp          Brad Miller's resources package.
      nregex.lisp             Lawrence Freil's regular expression matching code
   The Lisp Utilities repository is maintained by Mark Kantrowitz,
   [e-mail].